#include "point.h"


//--------------------- Constructeurs et destructeur -------------------

/* ****************************************************************
 * Constructeur par défault, on initialise le point à la position (0.0, 0.0, 0.0)
 * **************************************************************** */
Point::Point()
{
    _x = _y = _z = 0.0;
}

/* ****************************************************************
 * Constructeur à 3 paramètres
 * @param x : coordonnée en x du point
 * @param y : coordonnée en y du point
 * @param z : coordonnée en z du point
 * **************************************************************** */
Point::Point(GLfloat x, GLfloat y, GLfloat z)
    : _x(x), _y(y), _z(z)
{

}

/* ****************************************************************
 * Constructeur à 1 paramètres à partir d'un point
 * @param p : point recopié
 * **************************************************************** */
Point::Point(const Point& p)
    : _x(p._x), _y(p._y), _z(p._z)
{
}

/* ****************************************************************
 * On définit le destructeur
 * **************************************************************** */
Point::~Point()
{
    //Rien à faire
}
//----------------------------------------------------------------------
//--------------------- Méthodes ---------------------------------------
/* ****************************************************************
 * On renvoie une copie du point courant
 * @return Point : copie du point
 * **************************************************************** */
Point* Point::cloner()
{
    return new Point(this->_x,this->_y,this->_z);
}
//----------------------------------------------------------------------

//--------------------- Accesseurs -------------------------------------

/* ****************************************************************
 * On renvoie la coordonnée en x
 * @return GLfloat : coordonnée en x du point
 * **************************************************************** */
GLfloat Point::getX()
{
    return _x;
}

/* ****************************************************************
 * On renvoie la coordonnée en y
 * @return GLfloat : coordonnée en y du point
 * **************************************************************** */
GLfloat Point::getY()
{
    return _y;
}

/* ****************************************************************
 * On renvoie la coordonnée en z
 * @return GLfloat : coordonnée en z du point
 * **************************************************************** */
GLfloat Point::getZ()
{
    return _z;
}

/* ****************************************************************
 * On affecte x par une nouvelle valeur
 * @param x : nouvelle valeur de x
 * **************************************************************** */
void Point::setX(GLfloat x)
{
    this->_x = x;
}

/* ****************************************************************
 * On affecte y par une nouvelle valeur
 * @param y : nouvelle valeur de y
 * **************************************************************** */
void Point::setY(GLfloat y)
{
    this->_y = y;
}

/* ****************************************************************
 * On affecte z par une nouvelle valeur
 * @param z : nouvelle valeur de z
 * **************************************************************** */
void Point::setZ(GLfloat z)
{
    this->_z = z;
}

//----------------------------------------------------------------------
//--------------------- Surcharge des opérateurs -----------------------

/* ****************************************************************
 * On surcharge l'opérateur += de la classe Point. On rajoute le point passé
 * en paramètre au point courant.
 * @param Point p : le point à ajouter au point courant
 * **************************************************************** */
void Point::operator+=(const Point& p)
{
    this->_x += p._x;
    this->_y += p._y;
    this->_z += p._z;
}


/* ****************************************************************
 * On surcharge l'opérateur /= de la classe Point.
 * @param Point pt2 : le point à ajouter au point courant
 * @return Point : on renvoie le point courant
 * **************************************************************** */
Point& Point::operator/=(const Point &pt2)
{
    this->_x /= pt2._x;
    this->_y /= pt2._y;
    this->_z /= pt2._z;

    return (*this);
}

//----------------------------------------------------------------------

